package com.yidu.hbatsams.service.Impl;

import com.github.pagehelper.PageHelper;
import com.yidu.hbatsams.dao.*;
import com.yidu.hbatsams.domain.*;
import com.yidu.hbatsams.service.AtsSchemeImpl;
import com.yidu.hbatsams.utils.Message;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.List;
import java.util.Map;

@Service
@Transactional
public class AtsSchemeService implements AtsSchemeImpl {

    @Resource
    AtsSchemeMapper atsSchemeMapper;

    @Resource
    AtsEmpAthleteMapper atsEmpAthleteMapper;

    @Resource
    AtsSchemeExpertMapper atsSchemeExpertMapper;

    @Resource
    AtsEmpCoachAthleteMapper atsEmpCoachAthleteMapper;

    @Resource
    AtsSchemeAthleteMapper atsSchemeAthleteMapper;

    @Resource
    AtsEmpExpertMapper atsEmpExpertMapper;

    @Resource
    AtsSchemeAuditMapper atsSchemeAuditMapper;

    @Override
    public List<AtsScheme> selectAll(AtsScheme atsScheme,Integer pageNum,Integer pageSize) {
        PageHelper.offsetPage(pageNum,pageSize);//调用PageHelper的offsetPage方法实现分页
        PageHelper.startPage(pageNum,pageSize);//调用PageHelper的startPage方法实现分页
        return atsSchemeMapper.selectAll(atsScheme);//返回方案表的查询全部
    }

    @Override
    public int selectAllCount(AtsScheme atsScheme) {
        return atsSchemeMapper.selectAllCount(atsScheme);//调用方案表的方法
    }

    /**
     * 插入专家咨询表中
     * @param atsSchemeExpert
     * @return
     */
    @Override
    public int atsSchemeExpertInsert(AtsSchemeExpert atsSchemeExpert) {
        return atsSchemeExpertMapper.insertSelective(atsSchemeExpert);//调用专家表的插入选择方法
    }



    /**
     * 查询所有运动员
     * @return List<AtsEmpAthlete>
     */
    @Override
    public List<AtsEmpAthlete> selectAllAts(){

        return atsEmpAthleteMapper.selectAll();//查询所有运动员
    }

    /**
     * 查询方案是否已被申请过
     * @param schemeId
     * @return AtsSchemeExpert
     */
    @Override
    public List<AtsSchemeExpert> selectExist(Integer schemeId) {
        return atsSchemeExpertMapper.selectExist(schemeId);//查询是否存在
    }

    @Override
    public AtsEmpAthlete selectAts(Integer athleteId) {
        return atsEmpAthleteMapper.selectByPrimaryKey(athleteId);//查询主键方法
    }

    @Override
    public int deleteByPrimaryKey(Integer schemeId) {
        return atsSchemeMapper.deleteByPrimaryKey(schemeId);//调用方案表删除主键方法
    }

    @Override
    public int insert(AtsScheme record) {
        return atsSchemeMapper.insert(record);//调用方案表插入方法
    }

    @Override
    public Message insertSelective(AtsScheme record) {
        Message mg = new Message();//创建一个消息对象
        int count = atsSchemeMapper.insertSelective(record);//调用方案表的插入选择方法
        if(count>0){ //如果count大于0
            mg.setNum(record.getSchemeId());//将对象中的方案id放入num中
            mg.setMsg("操作成功");//操作成功
        }else{//否则
            mg.setNum(0);//将0保存在其中
            mg.setMsg("操作失败");//操作失败
        }
        return mg;//返回mg
    }

    @Override
    public AtsScheme selectByPrimaryKey(Integer schemeId) {
        return atsSchemeMapper.selectByPrimaryKey(schemeId);//调用方案表的方法
    }

    @Override
    public int updateByPrimaryKeySelective(AtsScheme record) {

        return atsSchemeMapper.updateByPrimaryKeySelective(record);//调用方案表的方法
    }

    @Override
    public int updateByPrimaryKey(AtsScheme record) {
        return atsSchemeMapper.updateByPrimaryKey(record);//调用方案表的方法
    }

    /**
     * 根据教练员id查询运动员
     * @param coachId
     * @return AtsEmpCoachAthlete
     */
    @Override
    public List<AtsEmpCoachAthlete> selectaths(Integer coachId) {
        return atsEmpCoachAthleteMapper.selectaths(coachId);//调用atsEmpCoachAthleteMapper的方法
    }

    @Override
    public int insertAtsSchemeAthlete(AtsSchemeAthlete atsSchemeAthlete) {
        return atsSchemeAthleteMapper.insertSelective(atsSchemeAthlete);//调用atsSchemeAthleteMapper的插入选择方法
    }

    @Override
    public int updateAtsSchemeAthlete(AtsSchemeAthlete atsSchemeAthlete) {
        return atsSchemeAthleteMapper.updateByPrimaryKeySelective(atsSchemeAthlete);//调用atsSchemeAthleteMapper的修改主键选择方法
    }

    @Override
    public List<AtsSchemeAthlete> selectschemeId(Integer schemeId) {
        return atsSchemeAthleteMapper.selectschemeId(schemeId);//调用atsSchemeAthleteMapper的方法
    }

    @Override
    public int deleteAthleteId(Integer schemeId) {
        return atsSchemeAthleteMapper.deleteAthleteId(schemeId);//调用atsSchemeAthleteMapper的方法
    }

    /**
     * 删除方案
     * @param schemeId
     * @return int
     */
    @Override
    public int deleteScheme(Integer schemeId) {

        return atsSchemeMapper.deleteScheme(schemeId);//调用方案表的方法
    }

    @Override
    public void deleteScheme(Integer[] schemeIds) {
        for (Integer schemeId : schemeIds) { //循环数组
            atsSchemeMapper.deleteScheme(schemeId); //调用方案表的方法
        }
    }

    /**
     * 将方案对应的运动员表的数据改成无效数据
     * @param schemeId
     * @return int
     */
    @Override
    public int updateIsva(Integer schemeId) {
        return atsSchemeAthleteMapper.updateIsva(schemeId);//调用atsSchemeAthleteMapper的方法
    }

    @Override
    public void updateIsva(Integer[] schemeIds) {
        for (Integer schemeId : schemeIds) { //循环数组
            atsSchemeAthleteMapper.updateIsva(schemeId);//调用atsSchemeAthleteMapper的方法
        }
    }

    /**
     * 查询专家
     * @return List<AtsEmpExpert>
     */
    @Override
    public List<AtsEmpExpert> selectAtsEmpExpert() {
        return atsEmpExpertMapper.selectAll(null,null,null);//调用atsEmpExpertMapper的查询全部方法
    }

    /**
     * 给审核表插入数据,与专家咨询表增加专家
     * @param atsSchemeAudit，atsSchemeExpert
     * @return int
     */
    @Override
    public Message atsSchemeAuditMapperInsert(AtsSchemeAudit atsSchemeAudit,AtsSchemeExpert atsSchemeExpert) {
        Message mg = new Message();//创建一个消息对象
        int count = atsSchemeAuditMapper.insertSelective(atsSchemeAudit);//调用atsSchemeAuditMapper的插入选择方法并用整数count接收
        int result = atsSchemeExpertMapper.updateSelective(atsSchemeExpert);//调用atsSchemeExpertMapper的修改选择方法并用整数result接收
        if(count>0 && result>0){ //如果两个整数都大于0
            mg.setMsg("已审核"); //表示已经审核
        }else{//否则
            mg.setMsg("网路不行");//表示网络不行
        }

        return mg;//返回mg
    }

    /**
     * 根据业务id查询审核表
     * @param saId
     * @return List<AtsSchemeAudit>
     */
    @Override
    public List<AtsSchemeAudit> atsSchemeAuditSelectBySaId(String saId) {
        return atsSchemeAuditMapper.selectByPrimaryKeySaId(saId);//返回atsSchemeAuditMapper的查询主键方法
    }

    /**
     * 查询审核意见
     * @param saId
     * @return List<AtsSchemeAudit>
     */
    @Override
    public List<AtsSchemeAudit> selectAuExp(Integer saId){
        return null;
    }


    /**
     * 修改专家咨询表
     * @param atsSchemeExpert
     * @return int
     */
    @Override
    public int atsSchemeExpertUpdateByPrimaryKeySelective(AtsSchemeExpert atsSchemeExpert){
        return atsSchemeExpertMapper.updateSelective(atsSchemeExpert);//调用atsSchemeExpertMapper的修改选择方法
    }

    /**
     * 根据方案id和运动员id更改方案对应的运动员表
     * @param atsSchemeAthlete
     * @return int
     */
    @Override
    public int updateAtsSchemeAthletes(AtsSchemeAthlete atsSchemeAthlete){
        return atsSchemeAthleteMapper.updateAtsSchemeAthlete(atsSchemeAthlete);//调用atsSchemeAthleteMapper的修改方案运动员方法
    }

    /**
     * 查询审核表
     * @return List<AtsSchemeAudit>
     */
    @Override
    public List<AtsSchemeAudit> selectAtsSchemeAudit(){
        return atsSchemeAuditMapper.selectAll();//调用atsSchemeAuditMapper的查询全部方法
    }

    /**
     * 根据方案id修改审核数据表
     * @param atsSchemeAudit
     * @return int
     */
    @Override
    public void updateAtsSchemeAudit(AtsSchemeAudit atsSchemeAudit){
        atsSchemeAuditMapper.updateByPrimaryKeySelectiveFs(atsSchemeAudit);//调用atsSchemeAuditMapper的修改主键选择fs方法
    }
    /**
     * 根据运动员id查询信息
     * @param athleteId
     * @return List<AtsSchemeAthlete>
     */
    @Override
    public List<AtsSchemeAthlete> selectByAthleteId(Integer athleteId){
        return atsSchemeAthleteMapper.selectByAthleteId(athleteId);//调用atsSchemeAthleteMapper的查询运动员id的方法
    }

    /**
     * 根据方案id查询信息
     * @param map
     * @return List<AtsScheme>
     */
    @Override
    public List<AtsScheme> selectByPrimaryKeyAthlete(Map<String,Object> map, Integer pageNum, Integer pageSize){
        PageHelper.offsetPage(pageNum,pageSize);//调用PageHelper的offsetPage方法实现分页
        PageHelper.startPage(pageNum,pageSize);//调用PageHelper的startPage方法实现分页
        return atsSchemeMapper.selectByPrimaryKeyAthlete(map);//返回方案表的查询主键运动员方法传入map
    }
    /**
     * 查询总页数
     * @param map
     * @return int
     */
    @Override
    public int selectByPrimaryKeyAthleteCount(Map<String,Object> map){
        return atsSchemeMapper.selectByPrimaryKeyAthleteCount(map);//调用方案表的方法
    }
}
